package com.bdbit.ChargingStation.controller;

import com.bdbit.ChargingStation.entity.ChargingPile;
import com.bdbit.ChargingStation.entity.OrderEntity;
import com.bdbit.ChargingStation.entity.bean_order;
import com.bdbit.ChargingStation.mapper.ChargingPileMapper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 这个类主要作用就是获取充电桩列表之类的
 * 前期页面测试需要，测试
 */
@Slf4j
@RestController
@RequestMapping("/api/charging")
public class ChargingPileController {

    @Autowired
    private ChargingPileMapper chargingPileMapper;
    // 新增：获取所有充电桩信息
    /**
     * 获取所有充电桩信息
     *
     * @return ApiResponse 包含所有充电桩列表
     */
    @GetMapping("/getAllChargingPiles")
    public ApiResponse getAllChargingPiles() {
        try {
            List<ChargingPile> allPiles = chargingPileMapper.selectAll();
            return ApiResponse.success(allPiles);
        } catch (Exception e) {
            return ApiResponse.error(500, "获取所有充电桩信息失败: " + e.getMessage());
        }
    }

    /**
     * 查询充电桩信息（支持多种查询模式）
     *
     * 查询模式：
     * 1. 按区域查询: 提供 region_code
     * 2. 按电桩号查询: 提供 ele_code
     * 3. 按区域+电桩号精确查询: 同时提供 region_code 和 ele_code
     *
     * @param regionCode 区域代码（可选）
     * @param eleCode 电桩代码（可选）
     * @return ApiResponse 包含查询结果
     */
    // 新增：获取充电桩信息接口
    @GetMapping("/getChargingPiles")
    public ChargingPileController.ApiResponse getChargingPiles(
            @RequestParam(value = "region_code", required = false) String regionCode,
            @RequestParam(value = "ele_code", required = false) String eleCode) {

        try {
            List<ChargingPile> resultList;

            // 模式0: 无任何参数时返回全部
            if (StringUtils.isEmpty(regionCode) && StringUtils.isEmpty(eleCode)) {
                resultList = chargingPileMapper.selectAll();
            }
            // 模式1: 只提供区域编码
            else if (!StringUtils.isEmpty(regionCode) && StringUtils.isEmpty(eleCode)) {
                resultList = chargingPileMapper.selectByRegion(regionCode);
            }
            // 模式2: 只提供电桩号
            else if (StringUtils.isEmpty(regionCode) && !StringUtils.isEmpty(eleCode)) {
                resultList = chargingPileMapper.selectByEleCode(eleCode);
            }
            // 模式3: 提供区域+电桩号
            else {
                ChargingPile pile = chargingPileMapper.selectByRegionAndCode(regionCode, eleCode);
                resultList = pile != null ? Collections.singletonList(pile) : Collections.emptyList();
            }

            return ChargingPileController.ApiResponse.success(resultList);
        } catch (Exception e) {
            return ChargingPileController.ApiResponse.error(500, "查询失败: " + e.getMessage());
        }
    }

    /**
     * 新增充电桩
     *
     * @param pile 充电桩实体对象
     * @return ApiResponse 操作结果
     */
    @PostMapping("/addChargingPile")
    public ApiResponse addChargingPile(@RequestBody ChargingPile pile) {
        try {
            // 必填字段校验
            if (StringUtils.isEmpty(pile.getRegionCode()) ||
                    StringUtils.isEmpty(pile.getEleCode()) ||
                    StringUtils.isEmpty(pile.getEleName())) {
                return ApiResponse.error(400, "区域编码、电桩号和电桩名称不能为空");
            }

            // 检查是否已存在
            ChargingPile existing = chargingPileMapper.selectByRegionAndCode(
                    pile.getRegionCode(), pile.getEleCode());
            if (existing != null) {
                return ApiResponse.error(409, "充电桩已存在（区域编码+电桩号必须唯一）");
            }

            int result = chargingPileMapper.insertChargingPile(pile);
            if (result > 0) {
                return ApiResponse.success(Collections.singletonList(pile), "充电桩添加成功");
            }
            return ApiResponse.error(500, "充电桩添加失败");
        } catch (DuplicateKeyException e) {
            return ApiResponse.error(409, "充电桩已存在（区域编码+电桩号必须唯一）");
        } catch (Exception e) {
            return ApiResponse.error(500, "添加失败: " + e.getMessage());
        }
    }

    /**
     * 更新充电桩信息
     *
     * @param pile 充电桩实体对象
     * @return ApiResponse 操作结果
     */
    @PutMapping("/updateChargingPile")
    public ApiResponse updateChargingPile(@RequestBody ChargingPile pile) {
        try {
            // 必填字段校验
            if (StringUtils.isEmpty(pile.getRegionCode()) ||
                    StringUtils.isEmpty(pile.getEleCode())) {
                return ApiResponse.error(400, "区域编码和电桩号不能为空");
            }

            ChargingPile existing = chargingPileMapper.selectByRegionAndCode(
                    pile.getRegionCode(), pile.getEleCode());

            if (existing == null) {
                return ApiResponse.error(404, "充电桩不存在");
            }

            // 更新字段（避免覆盖未提供的字段）
            boolean changed = false;

            // 添加 regionName 更新逻辑（从这里开始）
            if (!StringUtils.isEmpty(pile.getRegionName()) &&
                    !pile.getRegionName().equals(existing.getRegionName())) {
                existing.setRegionName(pile.getRegionName());
                changed = true;
                log.debug("更新 regionName: {} -> {}", existing.getRegionName(), pile.getRegionName());
            }
            // 到这里结束

            if (!StringUtils.isEmpty(pile.getEleName()) &&
                    !pile.getEleName().equals(existing.getEleName())) {
                existing.setEleName(pile.getEleName());
                changed = true;
                log.debug("更新 eleName: {} -> {}", existing.getEleName(), pile.getEleName());
            }

            if (pile.getStatus() != null) {
                existing.setStatus(pile.getStatus());
                changed = true;
                log.debug("更新 status: {} -> {}", existing.getStatus(), pile.getStatus());
            }

            if (!StringUtils.isEmpty(pile.getEleOldUrl())) {
                existing.setEleOldUrl(pile.getEleOldUrl());
                changed = true;
                log.debug("更新 eleOldUrl: {} -> {}", existing.getEleOldUrl(), pile.getEleOldUrl());
            }

            if (!StringUtils.isEmpty(pile.getElenewUrl())) {
                existing.setElenewUrl(pile.getElenewUrl());
                changed = true;
                log.debug("更新 Elenewurl: {} -> {}", existing.getElenewUrl(), pile.getElenewUrl());
            }

            if (pile.getType() != null) {
                existing.setType(pile.getType());
                changed = true;
                log.debug("更新 type: {} -> {}", existing.getType(), pile.getType());
            }

            if (!changed) {
                log.info("没有需要更新的字段");
                return ApiResponse.success(Collections.singletonList(existing), "数据未变化");
            }

            int result = chargingPileMapper.updateChargingPile(existing);
            if (result > 0) {
                return ApiResponse.success(Collections.singletonList(existing), "充电桩更新成功");
            }
            return ApiResponse.error(500, "充电桩更新失败");
        } catch (Exception e) {
            return ApiResponse.error(500, "更新失败: " + e.getMessage());
        }
    }


    /**
     * 删除充电桩
     *
     * @param regionCode 区域编码
     * @param eleCode 电桩号
     * @return ApiResponse 操作结果
     */
    @DeleteMapping("/deleteChargingPile")
    @Transactional
    public ApiResponse deleteChargingPile(
            @RequestParam("region_code") String regionCode,
            @RequestParam("ele_code") String eleCode) {
        try {
            log.info("收到删除请求: regionCode={}, eleCode={}", regionCode, eleCode);

            // 参数校验
            if (StringUtils.isEmpty(regionCode) || StringUtils.isEmpty(eleCode)) {
                log.warn("参数校验失败: 区域编码或电桩号为空");
                return ApiResponse.error(400, "区域编码和电桩号不能为空");
            }

            log.debug("查询充电桩是否存在");
            ChargingPile existing = chargingPileMapper.selectByRegionAndCode(regionCode, eleCode);
            if (existing == null) {
                log.warn("充电桩不存在: regionCode={}, eleCode={}", regionCode, eleCode);
                return ApiResponse.error(404, "充电桩不存在");
            }

            log.debug("准备删除充电桩: {}", existing);

            int result = chargingPileMapper.deleteChargingPile(regionCode, eleCode);
            log.info("删除操作结果: 影响行数={}", result);

            if (result > 0) {
                log.info("删除成功");
                return ApiResponse.success(null, "充电桩删除成功");
            }

            log.error("删除失败, 影响行数为0");
            return ApiResponse.error(500, "充电桩删除失败");
        } catch (Exception e) {
            log.error("删除充电桩异常", e);
            return ApiResponse.error(500, "删除失败: " + e.getMessage());
        }
    }

    /**
     * 批量删除充电桩
     *
     * @param piles 要删除的充电桩列表（包含regionCode和eleCode）
     * @return ApiResponse 操作结果
     */
    @DeleteMapping("/batchDeleteChargingPile")
    @Transactional
    public ApiResponse batchDeleteChargingPile(@RequestBody List<ChargingPile> piles) {
        try {
            log.info("收到批量删除请求: 数量={}", piles != null ? piles.size() : 0);

            if (piles == null || piles.isEmpty()) {
                log.warn("请求参数为空");
                return ApiResponse.error(400, "请选择要删除的充电桩");
            }

            // 过滤有效条目
            List<ChargingPile> validPiles = piles.stream()
                    .filter(pile -> !StringUtils.isEmpty(pile.getRegionCode()) &&
                            !StringUtils.isEmpty(pile.getEleCode()))
                    .collect(Collectors.toList());

            if (validPiles.isEmpty()) {
                log.warn("没有有效的充电桩标识");
                return ApiResponse.error(400, "没有有效的充电桩标识");
            }

            log.info("有效删除条目: {}", validPiles.size());
            int successCount = 0;

            for (ChargingPile pile : validPiles) {
                try {
                    log.debug("删除充电桩: regionCode={}, eleCode={}",
                            pile.getRegionCode(), pile.getEleCode());

                    int result = chargingPileMapper.deleteChargingPile(
                            pile.getRegionCode(), pile.getEleCode());

                    if (result > 0) {
                        successCount++;
                        log.debug("删除成功");
                    } else {
                        log.warn("删除失败: regionCode={}, eleCode={}",
                                pile.getRegionCode(), pile.getEleCode());
                    }
                } catch (Exception e) {
                    log.error("删除单个充电桩异常", e);
                }
            }

            if (successCount > 0) {
                log.info("批量删除成功: {}/{}", successCount, validPiles.size());
                return ApiResponse.success(null,
                        "成功删除 " + successCount + "/" + validPiles.size() + " 个充电桩");
            }

            log.error("批量删除失败, 所有条目删除失败");
            return ApiResponse.error(500, "批量删除失败");
        } catch (Exception e) {
            log.error("批量删除异常", e);
            return ApiResponse.error(500, "批量删除失败: " + e.getMessage());
        }
    }


    /**
     * 统一API响应结构
     * 用于封装接口返回的通用数据格式，包含状态码、消息和数据
     */
    @Data
    static class ApiResponse {
        private int code;
        private String message;
        private List<ChargingPile> data;
        private List<OrderEntity> datas;

        /**
         * 构建成功响应（带数据）
         * @param data 响应数据
         * @return ApiResponse 包含成功状态码和数据的响应对象
         */
        public static ApiResponse success(List<ChargingPile> data) {
            return success(data, "success");
        }

        public static ApiResponse success_order(List<OrderEntity> data) {
            return success_order(data, "success");
        }
        /**
         * 构建成功响应（带自定义消息）
         * @param data 响应数据
         * @param message 自定义消息
         * @return ApiResponse 包含成功状态码、数据和自定义消息的响应对象
         */
        public static ApiResponse success(List<ChargingPile> data, String message) {
            ApiResponse response = new ApiResponse();
            response.code = 0;
            response.message = message;
            response.data = data;
            return response;
        }

        public static ApiResponse success_order(List<OrderEntity> data, String message) {
            ApiResponse response = new ApiResponse();
            response.code = 0;
            response.message = message;
            response.datas = data;
            return response;
        }

        /**
         * 构建成功响应（仅消息）
         * @param message 自定义消息
         * @return ApiResponse 包含成功状态码和自定义消息的响应对象，数据为空列表
         */
        public static ApiResponse success(String message) {
            ApiResponse response = new ApiResponse();
            response.code = 0;
            response.message = message;
            response.data = Collections.emptyList();
            return response;
        }

        /**
         * 构建错误响应
         * @param code 错误码
         * @param message 错误消息
         * @return ApiResponse 包含指定错误码和消息的响应对象，数据为空列表
         */
        public static ApiResponse error(int code, String message) {
            ApiResponse response = new ApiResponse();
            response.code = code;
            response.message = message;
            response.data = Collections.emptyList();
            return response;
        }
    }
}